39.控制结构 ( if-else语句 、for循环 、while循环)

def calculate_tax(salary):
    """
    计算个人所得税(简化版)
    中国个人所得税采用7级超额累进税率
    """
    # 使用if-elif-else匹配累进税率表
    if salary <= 3000:
        rate, deduction = 0, 0
    elif salary <= 12000:
        rate, deduction = 0.03, 0
    elif salary <= 25000:
        rate, deduction = 0.10, 210
    elif salary <= 35000:
        rate, deduction = 0.20, 1410
    elif salary <= 55000:
        rate, deduction = 0.25, 2660
    elif salary <= 80000:
        rate, deduction = 0.30, 4410
    else:
        rate, deduction = 0.35, 7160

    # 应纳税所得额 = 税前工资 - 起征点(5000元)
    taxable_income = salary - 5000
    # 应纳税额 = 应纳税所得额 × 税率 - 速算扣除数
    tax = max(0, taxable_income * rate - deduction)
    after_tax = salary - tax
    return tax, after_tax

# 测试不同收入水平
salaries = [2500, 5000, 15000, 30000, 60000, 100000]
print('工资扣税计算:')
print('-' * 60)
for salary in salaries:
    tax, after_tax = calculate_tax(salary)
    tax_rate = tax / salary * 100 if salary > 0 else 0
    print(f'税前工资: {salary:8.2f}元 | 税额: {tax:7.2f}元 | 税率: {tax_rate:5.2f}% | 税后: {after_tax:8.2f}元')

def generate_signal(price, ma20, ma60, volume, avg_volume, rsi):
    """基于技术指标的多条件嵌套判断"""
    signal = 'HOLD'
    reason = []

    # 第一层：判断市场趋势（均线排列）
    if ma20 > ma60:
        reason.append('均线多头')
        # 第二层：价格是否突破均线
        if price > ma20:
            reason.append('突破20日均线')
            # 第三层：量价配合 + RSI确认
            if volume > avg_volume * 1.2 and rsi < 70:
                signal = 'BUY'
                reason.append('放量上涨')
    elif ma20 < ma60:
        reason.append('均线空头')
        if price < ma20:
            reason.append('跌破20日均线')
            if volume > avg_volume * 1.2 and rsi > 30:
                signal = 'SELL'
                reason.append('放量下跌')
    else:
        reason.append('均线纠缠,观望')

    return signal, '; '.join(reason)

# 测试不同市场情景
signals = [
    (18.5, 18.0, 17.5, 2500000, 2000000, 45),
    (18.5, 18.0, 17.5, 1500000, 2000000, 65),
    (18.5, 18.0, 17.5, 2500000, 2000000, 75),
    (16.5, 18.0, 17.5, 2500000, 2000000, 25),
]
print('交易信号分析:')
print('-' * 80)
for price, ma20, ma60, volume, avg_vol, rsi in signals:
    signal, reason = generate_signal(price, ma20, ma60, volume, avg_vol, rsi)
    print(f'价格={price:.1f}, MA20={ma20:.1f}, MA60={ma60:.1f}, 信号={signal}, 原因=[{reason}]')

import numpy as np

# ===== 案例1：复利终值计算 =====
principal = 10000  # 本金
rate = 0.05        # 年利率5%
years = 10         # 投资10年

print('复利增长过程:')
print('-' * 50)
print(f'{"年份":<6}{"年初本金":<12}{"利息":<12}{"年末余额":<12}')
print('-' * 50)

amount = principal
# range(1, years+1) 生成 [1,2,...,10]
for year in range(1, years + 1):
    interest = amount * rate        # 当年利息
    amount += interest              # 累加到余额
    print(f'{year:<6}{amount - interest:<12.2f}{interest:<12.2f}{amount:<12.2f}')

# 复利 vs 单利对比
print(f'\n复利终值: {amount:.2f}元')
simple_interest = principal * (1 + rate * years)
print(f'单利对比: {simple_interest:.2f}元')
print(f'复利优势: {amount - simple_interest:.2f}元')

import numpy as np

# 日收益率序列（10个交易日）
daily_returns = [0.02, -0.01, 0.03, -0.02, 0.01, 0.04, -0.03, 0.02, -0.01, 0.01]

# ===== 手动计算标准差 =====
n = len(daily_returns)
mean_return = sum(daily_returns) / n

# 列表推导式计算方差
variance = sum([(r - mean_return) ** 2 for r in daily_returns]) / (n - 1)
volatility_daily = np.sqrt(variance)

# 年化波动率 = 日波动率 × √252
volatility_annual = volatility_daily * np.sqrt(252)

print(f'日收益率: {daily_returns}')
print(f'均值: {mean_return:.4f}')
print(f'手动计算年化波动率: {volatility_annual:.4f}')
print(f'NumPy计算年化波动率: {np.std(daily_returns) * np.sqrt(252):.4f}')

import numpy as np

def sqrt_newton(x, tolerance=1e-6, max_iter=100):
    """
    牛顿迭代法计算√2
    迭代公式: x_{n+1} = 0.5 * (x_n + S/x_n)
    """
    S = 2.0
    x_old = x

    print(f'牛顿法求√{S}:')
    print(f'{"迭代":<6}{"近似值":<15}{"误差":<15}')
    print('-' * 40)

    for i in range(max_iter):
        x_new = 0.5 * (x_old + S / x_old)  # 牛顿迭代
        error = abs(x_new - x_old)           # 绝对误差
        print(f'{i+1:<6}{x_new:<15.10f}{error:<15.10f}')

        if error < tolerance:                # 检查收敛
            print(f'\n收敛! 迭代{i+1}次后达到精度要求')
            break
        x_old = x_new
    else:
        print(f'\n警告: 未在{max_iter}次内收敛')

    return x_new

sqrt_approx = sqrt_newton(1.0)
sqrt_actual = np.sqrt(2)
print(f'\n近似值: {sqrt_approx:.10f}')
print(f'实际值: {sqrt_actual:.10f}')
print(f'误差: {abs(sqrt_approx - sqrt_actual):.2e}')

import numpy as np

def implied_volatility(option_price, S, K, T, r=0.05, max_iter=100):
    """
    使用牛顿法求期权隐含波动率（简化版）
    牛顿迭代: σ_{n+1} = σ_n - (BS(σ_n) - MarketPrice) / Vega(σ_n)
    """
    sigma = 0.3       # 初始猜测30%
    tolerance = 1e-6

    for i in range(max_iter):
        # 简化版演示（实际需完整Black-Scholes + Vega）
        price_diff = option_price - (S * 0.6)
        sigma_new = sigma + price_diff * 0.1

        if abs(sigma_new - sigma) < tolerance:
            break
        sigma = sigma_new

    return sigma

print('隐含波动率计算:')
print('期权价格: 5.0元, 标的价格: 100元')
iv = implied_volatility(5.0, 100, 105, 1)
print(f'隐含波动率: {iv:.2%}')

# ===== break演示 =====
print('break演示(找到第一个正收益):')
returns = [-0.02, 0.03, -0.01, 0.04, 0.01, -0.03, 0.02]

for i, ret in enumerate(returns):
    if ret > 0:
        print(f'  第{i+1}天: {ret:.2%}')
        break  # 找到后立即退出

# ===== continue演示 =====
print('\ncontinue演示(跳过负收益):')
positive_count = 0
for ret in returns:
    if ret < 0:
        continue  # 负收益直接跳过
    positive_count += 1
    print(f'  正收益: {ret:.2%}')
print(f'\n正收益天数: {positive_count}天')

print('嵌套循环演示:')
for i in range(3):
    for j in range(3):
        if i == j:
            print(f'  ({i}, {j}): 对角线元素')
        else:
            continue
    # for-else：循环正常结束（未被break中断）时执行
    else:
        print(f'第{i}行完成')

def PV(R, *NCF, verbose=False):
    """
    计算现金流现值
    PV = Σ(CF_t / (1+r)^t)
    *NCF 接受任意数量的现金流
    """
    pv = 0
    n = 1
    print('现值计算过程:') if verbose else None
    print('-' * 60) if verbose else None

    for cf in NCF:
        discount_factor = 1 / (1 + R) ** n
        discounted_cf = cf * discount_factor
        pv += discounted_cf
        if verbose:
            print(f'  第{n}期: 现金流={cf:8.2f}, 折现因子={discount_factor:.6f}, 现值={discounted_cf:8.2f}')
        n += 1

    if verbose:
        print('-' * 60)
        print(f'现值总和: {pv:.2f}元')
    return pv

# 案例1：简单投资项目
print('案例1: 投资项目现金流')
pv1 = PV(0.05, -10000, 8000, 12000)
print(f'NPV(净现值): {pv1:.2f}元\n')

# 案例2：多期项目
print('案例2: 多期项目')
project_flows = [-50000, 10000, 15000, 20000, 25000, 30000]
pv2 = PV(0.08, *project_flows, verbose=True)

# 案例3：债券定价
print('\n案例3: 债券定价')
bond_flows = [50] * 9 + [1050]  # 10年期，票面5%，面值1000
pv_bond = PV(0.06, *bond_flows)
print(f'债券现值: {pv_bond:.2f}元\n')

import numpy as np

# ===== 阶乘 =====
def factorial(n):
    """n! = n × (n-1)!，基准: 0!=1, 1!=1"""
    if n <= 1:
        return 1
    return n * factorial(n - 1)

print('阶乘计算:')
for n in [1, 5, 10, 20]:
    print(f'{n}! = {factorial(n)}')

# ===== 斐波那契 =====
def fibonacci(n):
    """F(0)=0, F(1)=1, F(n)=F(n-1)+F(n-2)"""
    if n <= 1:
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)

print(f'\n斐波那契数列前10项:')
print([fibonacci(i) for i in range(10)])

import numpy as np

def binomial_tree(S, K, T, r, sigma, n, call=True):
    """
    Cox-Ross-Rubinstein二叉树模型
    u = e^(σ√dt), d = 1/u, p = (e^(r·dt) - d) / (u - d)
    """
    dt = T / n
    u = np.exp(sigma * np.sqrt(dt))   # 上涨因子
    d = 1 / u                          # 下跌因子
    p = (np.exp(r * dt) - d) / (u - d) # 风险中性概率

    # 终端节点期权价值
    option_values = np.zeros(n + 1)
    for j in range(n + 1):
        S_T = S * (u ** j) * (d ** (n - j))
        if call:
            option_values[j] = max(S_T - K, 0)
        else:
            option_values[j] = max(K - S_T, 0)

    # 从终端向根回推
    for i in range(n - 1, -1, -1):
        for j in range(i + 1):
            option_values[j] = np.exp(-r * dt) * (
                p * option_values[j + 1] + (1 - p) * option_values[j]
            )
    return option_values[0]

# 注：生产环境中可使用n=100或更高步数以提升精度
option_price = binomial_tree(S=100, K=105, T=1, r=0.05, sigma=0.2, n=20)
print(f'二叉树模型期权价格: {option_price:.2f}元')

x = 10  # 全局变量
y = 20

def func_local():
    """局部变量遮蔽全局变量"""
    x = 5  # 局部变量，不影响全局x
    print(f'函数内x: {x} (局部)')

def func_global():
    """使用global修改全局变量"""
    global y
    y = 50
    print(f'函数内y: {y} (修改后的全局)')

def func_enclosing():
    """闭包：内层函数访问外层变量"""
    z = 100
    def inner():
        return x + z  # x来自Global, z来自Enclosing
    return inner()

print('初始状态:')
print(f'全局x: {x}, 全局y: {y}')

func_local()
print(f'func_local()后, 全局x: {x} (未改变)')

func_global()
print(f'func_global()后, 全局y: {y} (已修改)')

print(f'闭包结果: {func_enclosing()}')

# 错误示例：忘记global
def modify_global_wrong():
    y = 30  # 创建局部变量，不影响全局y

print(f'\n错误示例测试:')
print(f'修改前全局y: {y}')
modify_global_wrong()
print(f'modify_global_wrong()后, 全局y: {y} (未修改,因为没有global)')

# 基本lambda函数
square = lambda x: x**2
cube = lambda x: x**3
print('lambda函数演示:')
print(f'平方: {square(5)} = {square(5)}')
print(f'立方: {cube(5)} = {cube(5)}')

# 金融收益率计算
simple_return = lambda initial, final: (final - initial) / initial
compound_return = lambda initial, rate, periods: initial * (1 + rate) ** periods - initial

print(f'\n简单收益率: {simple_return(100, 110):.2%}')
print(f'复利收益: {compound_return(10000, 0.05, 10):.2f}')

# 投资组合净值
net_value = lambda prices, shares: sum(p * s for p, s in zip(prices, shares))
prices = [10.5, 22.3, 15.8]
shares = [100, 200, 150]
print(f'\n投资组合净值: {net_value(prices, shares):.2f}元')

stocks = ['贵州茅台', '五粮液', '招商银行']
prices = [1850, 220, 45]

# map：对每个元素应用函数
formatted = list(map(lambda x: f'{x}元', prices))
print(f'格式化价格: {formatted}')

# filter：过滤符合条件的元素
expensive = list(filter(lambda p: p[1] > 200, zip(stocks, prices)))
print(f'高价股票: {[s + "=" + str(p) + "元" for s, p in expensive]}')

# sorted：自定义排序
portfolio = [
    {'name': '贵州茅台', 'return': 0.15},
    {'name': '五粮液', 'return': 0.08},
    {'name': '招商银行', 'return': 0.12}
]
sorted_portfolio = sorted(portfolio, key=lambda x: x['return'], reverse=True)
print(f'\n按收益率排序:')
for stock in sorted_portfolio:
    print(f"  {stock['name']}: {stock['return']:.2%}")

# 嵌套三元表达式
get_signal = lambda r: 'BUY' if r > 0.05 else ('SELL' if r < -0.02 else 'HOLD')

returns = [0.06, -0.03, 0.02, -0.01, 0.08]
signals = [get_signal(r) for r in returns]

print('交易信号:')
for r, s in zip(returns, signals):
    print(f'  收益率={r:6.2%}: 信号={s}')

# ⚠️ 平台原始代码 - 请原样输入至教学平台（注释除外），平台才会判定答案正确
#题目一
salary = 8000  # 基本工资
if salary <= 5000:  # 判断基本工资是否小于等于5000
    rate = 0  # 基本工资小于等于5000，不扣税，即扣税率为0%
else:  # 不满足以上条件时
    rate = 0.05  # 基本工资大于5000，扣税率为0.05，即5%

# 计算税后工资，基本工资-扣税，扣税额为超过3000部分的乘以扣税率
salary = salary - (salary - 5000) * rate
print("税后工资为：%d" % salary)  # 将税后工资打印输出

# 注：该代码块包含input()交互输入，渲染时无法执行
# ⚠️ 平台原始代码 - 请原样输入至教学平台（注释除外），平台才会判定答案正确
#题目二
sum_salary = 0
salary_list = []  # 定义列表salary_list
salary = 0  # 初始化薪资变量为0
while True:  # 条件循环
  salary = input('请输入员工的薪资,输入Q结束计算:')  # 获取用户键盘输入
  if salary.upper() == 'Q':  # 条件判断：salary.upper() == 'Q'
    print('程序结束')  # 输出程序结束
    break  # 跳出循环
  elif int(salary) <= 0:  # 否则判断：int(salary) <= 0
    print('您输入的数值有误,请重新输入')  # 输出您输入的数值有误,请重新输入
    continue  # 跳过本次迭代
    salary_list.append(salary)  # 将有效薪资数据添加到列表
  sum_salary += int(salary)  # 更新sum_salary的值
print(len(salary_list))  # 输出数据长度
print(sum_salary)  # 输出薪资数据

# 注：该代码块包含缩进错误的填空代码，需要在平台上完成
# ⚠️ 平台原始代码 - 请原样输入至教学平台（注释除外），平台才会判定答案正确
#题目三
Ri=[0.15,0.20,-0.10,0.35]        #收益率序列
Ai=[0.3,0.2,0.3,0.2]             #权重序列
TR=0  # 初始化投资组合期望报酬率为0
for j in range(len(Ri)):  # 遍历range(len(Ri))中的每个j
        TRij=Ri[j]*Ai[j]  # 计算第j项资产的加权收益贡献（收益率×权重）
    TR+=TRij  # 更新TR的值
print("投资组合的期望报酬率为：{:.2f}".format(TR))  # 输出投资组合的期望报酬率为：{:.2f}